// pages/course/PsychologicalCounselorCourse/Psychological Counselor Course.js
Page({

  /**
   * 页面的初始数据
   */
  data: {
    courseId: '',
    courseName: '',
    coursePrice: '',
    originalPrice: '',
    courseContent: '',
    courseImage: '',
    courseVideo: '',
    courseTime: '',
    courseMount: 0,
    expirationDate: 0,
    collects: 0,
    pjcount: 0,
    xuecount: 0,
    applicablePopulation: '',
    learnHarvest: '',
    subscriptionNotice: '',
    selectindex: 0,
    isshow: true,
    rate: 5,
    value: 5,
    courseMarks: [],
    teacherInfo: null,
    isCollected: false,
    // 评价相关数据
    showAddReview: false,
    reviewRating: 5,
    reviewContent: '',
    // 课堂交流相关数据
    latestPosts: [],
    lastReplyPosts: [], // 最后回复的帖子
    replyCountPosts: [], // 回复数量的帖子
    currentTab: '', // 当前选中的标签：latest-最新发帖，lastReply-最后回复，replyCount-回复数量
    showReplyInput: false,  // 添加回复输入框显示状态
    currentTalkId: '',      // 当前选中的帖子ID
    replyContent: ''        // 回复内容
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    if (options && options.id) {
      this.setData({ courseId: options.id });
      this.getCourseDetail(options.id);
    }
  },

  // 获取课程详情
  getCourseDetail(id) {
    wx.showLoading({
      title: '加载中...',
      mask: true
    });

    // 获取用户信息
    const userInfo = wx.getStorageSync('user');

    wx.request({
      url: `http://localhost:8080/courseDetails/getCourseDetails`,
      method: 'GET',
      data: { id: id },
      success: (res) => {
        console.log('课程详情接口响应：', res.data);
        if (res.data.code === 1 && res.data.data) {
          const courseData = res.data.data;
          this.setData({
            courseName: courseData.coursename,
            coursePrice: courseData.discountedPrice,
            originalPrice: courseData.originalprice,
            courseContent: courseData.courseintroduce,
            courseImage: 'http://localhost:8080/file/downLoad?fileName=' + courseData.tabularchart,
            courseVideo: courseData.coursevideo,
            courseTime: courseData.coursetime,
            courseMount: courseData.coursemount,
            expirationDate: courseData.expirationDate,
            collects: courseData.collects,
            pjcount: courseData.pjcount,
            xuecount: courseData.xuecount,
            applicablePopulation: courseData.applicablepopulation,
            learnHarvest: courseData.learnharvest,
            subscriptionNotice: courseData.subscriptionnotice
          });

          // 设置页面标题
          wx.setNavigationBarTitle({
            title: this.data.courseName
          });
          
          // 检查是否已收藏
          if (userInfo) {
            wx.request({
              url: 'http://localhost:8080/courseDetails/checkCollectStatus',
              method: 'GET',
              data: {
                userId: userInfo.userId || userInfo.id,
                courseId: id
              },
              success: (collectRes) => {
                if (collectRes.data.code === 1) {
                  this.setData({
                    isCollected: collectRes.data.data
                  });
                }
              }
            });
          }
          
          // 预加载评价数据
          this.getCourseMarks(id);
          
          // 如果有教师ID，获取教师信息
          if (courseData.teacherId) {
            this.getTeacherInfo(courseData.teacherId);
          }
        } else {
          wx.showToast({
            title: '获取课程信息失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('获取课程详情失败：', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {

  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {

  },

  show() {
    this.setData({
      isshow: !this.data.isshow
    });
  },

  change(e) {
    const index = parseInt(e.currentTarget.dataset.index);
    this.setData({
      selectindex: index
    });

    // 当切换到课程评价选项卡时，加载评价数据
    if (index === 3 && this.data.courseId) {
      this.getCourseMarks(this.data.courseId);
    }
    
    // 当切换到课堂交流选项卡时，自动加载最新发帖数据
    if (index === 2 && this.data.courseId) {
      wx.showLoading({
        title: '加载中...',
        mask: true
      });
      this.setData({
        currentTab: 'latest'  // 设置默认显示最新发帖
      });
      this.getLatestPosts();
    }
    
    // 当切换到名师介绍选项卡时，确保已加载教师信息
    if (index === 1 && !this.data.teacherInfo && this.data.courseId) {
      // 先获取课程详情以获取teacherId
      wx.request({
        url: `http://localhost:8080/courseDetails/getCourseDetails`,
        method: 'GET',
        data: { id: this.data.courseId },
        success: (res) => {
          if (res.data.code === 1 && res.data.data && res.data.data.teacherId) {
            this.getTeacherInfo(res.data.data.teacherId);
          }
        }
      });
    }
  },

  // 获取课程评价
  getCourseMarks(courseId) {
    wx.showLoading({
      title: '加载评价...',
      mask: true
    });

    wx.request({
      url: `http://localhost:8080/courseDetails/getCoursemarkById`,
      method: 'GET',
      data: { id: courseId },
      success: (res) => {
        console.log('课程评价接口响应：', res.data);
        if (res.data.code === 1 && res.data.data) {
          this.setData({
            courseMarks: res.data.data
          });
        } else {
          wx.showToast({
            title: '获取评价失败',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('获取课程评价失败：', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 获取教师信息
  getTeacherInfo(teacherId) {
    console.log('开始获取教师信息，教师ID：', teacherId);
    
    wx.request({
      url: `http://localhost:8080/courseDetails/getConsultById`,
      method: 'GET',
      data: { id: teacherId },
      success: (res) => {
        console.log('教师信息接口响应：', res.data);
        if (res.data.code === 1 && res.data.data) {
          const teacherData = res.data.data;
          
          // 处理擅长领域
          let specialties = '';
          if (teacherData.specialtyname) {
            // 检查specialtyname的类型并相应处理
            if (Array.isArray(teacherData.specialtyname)) {
              // 如果是数组，检查元素是否是对象
              if (teacherData.specialtyname.length > 0 && typeof teacherData.specialtyname[0] === 'object') {
                specialties = teacherData.specialtyname.map(item => item.name).join('、');
              } else {
                specialties = teacherData.specialtyname.join('、');
              }
            } else if (typeof teacherData.specialtyname === 'string') {
              specialties = teacherData.specialtyname;
            }
          }
          
          // 处理教师头像
          let teacherAvatar = '';
          if (teacherData.img) {
            // 检查img是否已经是完整URL
            if (teacherData.img.startsWith('http')) {
              teacherAvatar = teacherData.img;
            } else {
              // 否则添加前缀
              teacherAvatar = 'http://localhost:8080/file/downLoad?fileName=' + teacherData.img;
            }
          }
          
          console.log('教师详细信息：', {
            id: teacherData.id,
            name: teacherData.name,
            intro: teacherData.intro,
            gender: teacherData.sex,
            age: teacherData.age,
            location: teacherData.address,
            specialties: specialties,
            avatar: teacherAvatar
          });
          
          // 将教师信息保存到data中，以便在页面上显示
          this.setData({
            teacherInfo: {
              id: teacherData.id,
              name: teacherData.name,
              intro: teacherData.intro,
              gender: teacherData.sex,
              age: teacherData.age,
              location: teacherData.address,
              specialties: specialties,
              avatar: teacherAvatar
            }
          });
        } else {
          console.log('获取教师信息失败，接口返回错误：', res.data);
        }
      },
      fail: (err) => {
        console.error('获取教师信息失败：', err);
      }
    });
  },
  
  // 显示添加评价弹出框
  showAddReviewPopup() {
    // 获取用户数据
    const userInfo = wx.getStorageSync('user');
    console.log('当前用户数据：', userInfo);
    
    this.setData({
      showAddReview: true,
      reviewRating: 5,
      reviewContent: ''
    });
  },
  
  // 关闭添加评价弹出框
  closeAddReviewPopup() {
    this.setData({
      showAddReview: false
    });
  },
  
  // 评分变化处理
  onRatingChange(event) {
    this.setData({
      reviewRating: event.detail
    });
  },
  
  // 评价内容变化处理
  onReviewContentChange(event) {
    this.setData({
      reviewContent: event.detail.value
    });
  },
  
  // 添加评价接口封装
  addCoursemarkApi(coursemark) {
    return new Promise((resolve, reject) => {
      wx.request({
        url: 'http://localhost:8080/courseDetails/addCoursemark',
        method: 'POST',
        header: {
          'content-type': 'application/x-www-form-urlencoded'
        },
        data: `id=&content=${coursemark.content}&grade=${coursemark.grade}&createtime=${coursemark.createtime}&userId=${coursemark.userId}&courseId=${coursemark.courseId}`,
        success: (res) => {
          console.log('添加评价接口响应：', res.data);
          if (res.data.code === 1) {
            resolve(res.data);
          } else {
            reject(res.data.msg || '评价失败');
          }
        },
        fail: (err) => {
          console.error('添加评价失败：', err);
          reject('网络错误，请重试');
        }
      });
    });
  },
  
  // 提交评价
  submitReview() {
    // 检查评价内容是否为空
    if (!this.data.reviewContent.trim()) {
      wx.showToast({
        title: '请输入评价内容',
        icon: 'none'
      });
      return;
    }
    
    // 获取当前用户ID
    const userInfo = wx.getStorageSync('user');
    console.log('获取到的用户信息：', userInfo);
    
    // 更详细地检查用户信息
    if (!userInfo) {
      console.log('未找到用户信息');
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      return;
    }
    
    // 检查用户ID的多种可能属性名
    const userId = userInfo.userId || userInfo.id || userInfo.user_id;
    console.log('解析到的用户ID：', userId);
    
    if (!userId) {
      console.log('未找到有效的用户ID');
      wx.showToast({
        title: '登录信息异常，请重新登录',
        icon: 'none'
      });
      return;
    }
    
    // 获取当前日期，格式为yyyy-MM-dd
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    const createTime = `${year}-${month}-${day}`;
    
    // 构造Coursemark对象
    const coursemark = {
      
      content: this.data.reviewContent,
      grade: this.data.reviewRating,
      createtime: createTime,
      userId: userId,
      courseId: this.data.courseId
    };
    
    // 打印所有参数
    console.log('准备提交评价，参数如下：');
    console.log('评价内容:', coursemark.content);
    console.log('评分等级:', coursemark.grade);
    console.log('创建时间:', coursemark.createtime);
    console.log('用户ID:', coursemark.userId);
    console.log('课程ID:', coursemark.courseId);
    console.log('完整Coursemark对象:', coursemark);
    
    // 显示加载提示
    wx.showLoading({
      title: '提交中...',
      mask: true
    });
    
    // 调用添加评价接口
    this.addCoursemarkApi(coursemark)
      .then(() => {
        wx.showToast({
          title: '评价成功',
          icon: 'success'
        });
        
        // 关闭弹出框
        this.setData({
          showAddReview: false
        });
        
        // 重新加载评价数据
        this.getCourseMarks(this.data.courseId);
        
        // 更新评价数量
        this.setData({
          pjcount: this.data.pjcount + 1
        });
      })
      .catch((error) => {
        wx.showToast({
          title: error,
          icon: 'none'
        });
      })
      .finally(() => {
        wx.hideLoading();
      });
  },
  
  // 获取最新发表的课堂交流
  getLatestPosts() {
    // 检查是否有课程ID
    if (!this.data.courseId) {
      wx.showToast({
        title: '课程ID不存在',
        icon: 'none'
      });
      return;
    }
    
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    // 调用获取最新发表接口
    wx.request({
      url: 'http://localhost:8080/courseDetails/getCoursetalkByIdZuiXin',
      method: 'GET',
      data: { id: this.data.courseId },
      success: (res) => {
        console.log('获取最新发表接口响应：', res.data);
        
        if (res.data.code === 1 && res.data.data) {
          console.log('最新发表数据：', res.data.data);
          
          // 详细打印每个问题的回复数据结构
          res.data.data.forEach((item, index) => {
            console.log(`问题${index+1}:`, item.title);
            console.log(`问题${index+1}的回复数组:`, item.coursereplyCLF);
            
            // 如果有回复，打印第一个回复的详细信息
            if (item.coursereplyCLF && item.coursereplyCLF.length > 0) {
              console.log(`问题${index+1}的第一个回复:`, item.coursereplyCLF[0]);
              console.log(`回复内容:`, item.coursereplyCLF[0].replycontent);
              console.log(`回复时间:`, item.coursereplyCLF[0].createtime);
              console.log(`回复用户:`, item.coursereplyCLF[0].user);
              if (item.coursereplyCLF[0].user) {
                console.log(`回复用户昵称:`, item.coursereplyCLF[0].user.nickName);
              }
            }
          });
          
          // 处理数据，为每个问题添加showReplies属性
          const processedData = res.data.data.map(item => {
            // 确保coursereplyCLF是数组
            const coursereplyCLF = Array.isArray(item.coursereplyCLF) ? item.coursereplyCLF : [];
            
            // 确保每个回复的user对象存在
            coursereplyCLF.forEach(reply => {
              if (!reply.user) {
                reply.user = { nickName: '匿名用户' };
              }
            });
            
            // 使用Object.assign替代对象展开语法
            return Object.assign({}, item, {
              coursereplyCLF: coursereplyCLF,
              showReplies: false // 默认不显示回复
            });
          });
          
          // 更新数据
          this.setData({
            latestPosts: processedData,
            currentTab: 'latest'
          });
          
          console.log('处理后的数据：', processedData);
          
          wx.showToast({
            title: '数据已获取',
            icon: 'success'
          });
        } else {
          this.setData({
            latestPosts: []
          });
          wx.showToast({
            title: '暂无最新发表',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('获取最新发表失败：', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },
  
  // 显示回复输入框
  showReplyInput(e) {
    const talkId = e.currentTarget.dataset.talkid;
    console.log('显示回复输入框，帖子ID：', talkId);
    
    // 检查用户是否登录
    const userInfo = wx.getStorageSync('user');
    if (!userInfo) {
        wx.showToast({
            title: '请先登录',
            icon: 'none'
        });
        return;
    }
    
    this.setData({
        showReplyInput: true,
        currentTalkId: talkId,
        replyContent: ''
    });
  },

  // 关闭回复输入框
  closeReplyInput() {
    this.setData({
        showReplyInput: false,
        currentTalkId: '',
        replyContent: ''
    });
  },

  // 回复内容变化处理
  onReplyContentChange(e) {
    this.setData({
        replyContent: e.detail.value
    });
  },

  // 提交回复
  submitReply() {
    // 检查回复内容是否为空
    if (!this.data.replyContent.trim()) {
        wx.showToast({
            title: '请输入回复内容',
            icon: 'none'
        });
        return;
    }
    
    // 获取用户信息
    const userInfo = wx.getStorageSync('user');
    if (!userInfo) {
        wx.showToast({
            title: '请先登录',
            icon: 'none'
        });
        return;
    }
    
    // 获取当前日期
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    const createTime = `${year}-${month}-${day}`;
    
    // 显示加载提示
    wx.showLoading({
        title: '提交中...',
        mask: true
    });
    
    // 使用POST请求，但采用form-urlencoded格式
    wx.request({
        url: 'http://localhost:8080/courseDetails/addCoursereply',
        method: 'POST',
        header: {
            'content-type': 'application/x-www-form-urlencoded'
        },
        data: `id=&replytext=${encodeURIComponent(this.data.replyContent)}&createtime=${createTime}&talkId=${this.data.currentTalkId}&userId=${userInfo.userId || userInfo.id}`,
        success: (res) => {
            console.log('添加回复接口响应：', res.data);
            if (res.data.code === 1) {
                wx.showToast({
                    title: '回复成功',
                    icon: 'success'
                });
                
                // 关闭回复输入框
                this.closeReplyInput();
                
                // 刷新当前标签页数据
                if (this.data.currentTab === 'latest') {
                    this.getLatestPosts();
                } else if (this.data.currentTab === 'lastReply') {
                    this.getLastReplyPosts();
                } else if (this.data.currentTab === 'replyCount') {
                    this.getReplyCountPosts();
                }
            } else {
                wx.showToast({
                    title: res.data.msg || '回复失败',
                    icon: 'none'
                });
            }
        },
        fail: (err) => {
            console.error('添加回复失败：', err);
            wx.showToast({
                title: '网络错误，请重试',
                icon: 'none'
            });
        },
        complete: () => {
            wx.hideLoading();
        }
    });
  },

  // 修改切换回复显示状态方法
  toggleReplies(e) {
    const index = e.currentTarget.dataset.index;
    let currentPosts;
    let key;
    
    // 根据当前标签页确定要操作的数组
    if (this.data.currentTab === 'latest') {
        currentPosts = this.data.latestPosts;
        key = `latestPosts[${index}].showReplies`;
    } else if (this.data.currentTab === 'lastReply') {
        currentPosts = this.data.lastReplyPosts;
        key = `lastReplyPosts[${index}].showReplies`;
    } else if (this.data.currentTab === 'replyCount') {
        currentPosts = this.data.replyCountPosts;
        key = `replyCountPosts[${index}].showReplies`;
    }
    
    if (currentPosts && currentPosts[index]) {
        console.log('切换回复显示状态，当前项目：', currentPosts[index]);
        this.setData({
            [key]: !currentPosts[index].showReplies
        });
    }
  },

  // 获取最后回复的帖子
  getLastReplyPosts() {
    // 检查是否有课程ID
    if (!this.data.courseId) {
      wx.showToast({
        title: '课程ID不存在',
        icon: 'none'
      });
      return;
    }
    
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    // 调用获取最后回复接口
    wx.request({
      url: 'http://localhost:8080/courseDetails/getCoursetalkByIdZuiHou',
      method: 'GET',
      data: { id: this.data.courseId },
      success: (res) => {
        console.log('获取最后回复接口响应：', res.data);
        
        if (res.data.code === 1 && res.data.data) {
          console.log('最后回复数据：', res.data.data);
          
          // 详细打印每个问题的回复数据结构
          res.data.data.forEach((item, index) => {
            console.log(`问题${index+1}:`, item.title);
            console.log(`问题${index+1}的回复数组:`, item.coursereplyCLF);
            
            // 如果有回复，打印第一个回复的详细信息
            if (item.coursereplyCLF && item.coursereplyCLF.length > 0) {
              console.log(`问题${index+1}的第一个回复:`, item.coursereplyCLF[0]);
              console.log(`回复内容:`, item.coursereplyCLF[0].replycontent);
              console.log(`回复时间:`, item.coursereplyCLF[0].createtime);
              console.log(`回复用户:`, item.coursereplyCLF[0].user);
              if (item.coursereplyCLF[0].user) {
                console.log(`回复用户昵称:`, item.coursereplyCLF[0].user.nickName);
              }
            }
          });
          
          // 处理数据，为每个问题添加showReplies属性
          const processedData = res.data.data.map(item => {
            // 确保coursereplyCLF是数组
            const coursereplyCLF = Array.isArray(item.coursereplyCLF) ? item.coursereplyCLF : [];
            
            // 确保每个回复的user对象存在
            coursereplyCLF.forEach(reply => {
              if (!reply.user) {
                reply.user = { nickName: '匿名用户' };
              }
            });
            
            return Object.assign({}, item, {
              coursereplyCLF: coursereplyCLF,
              showReplies: false
            });
          });
          
          // 更新数据
          this.setData({
            lastReplyPosts: processedData,
            currentTab: 'lastReply'
          });
          
          console.log('处理后的最后回复数据：', processedData);
          
          wx.showToast({
            title: '数据已获取',
            icon: 'success'
          });
        } else {
          this.setData({
            lastReplyPosts: []
          });
          wx.showToast({
            title: '暂无最后回复',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('获取最后回复失败：', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 获取回复数量排序的帖子
  getReplyCountPosts() {
    // 检查是否有课程ID
    if (!this.data.courseId) {
      wx.showToast({
        title: '课程ID不存在',
        icon: 'none'
      });
      return;
    }
    
    // 显示加载提示
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    // 调用获取回复数量接口
    wx.request({
      url: 'http://localhost:8080/courseDetails/getCoursetalkByIdShuLiang',
      method: 'GET',
      data: { id: this.data.courseId },
      success: (res) => {
        console.log('获取回复数量接口响应：', res.data);
        
        if (res.data.code === 1 && res.data.data) {
          console.log('回复数量数据：', res.data.data);
          
          // 详细打印每个问题的回复数据结构
          res.data.data.forEach((item, index) => {
            console.log(`问题${index+1}:`, item.title);
            console.log(`问题${index+1}的回复数组:`, item.coursereplyCLF);
            
            // 如果有回复，打印第一个回复的详细信息
            if (item.coursereplyCLF && item.coursereplyCLF.length > 0) {
              console.log(`问题${index+1}的第一个回复:`, item.coursereplyCLF[0]);
              console.log(`回复内容:`, item.coursereplyCLF[0].replycontent);
              console.log(`回复时间:`, item.coursereplyCLF[0].createtime);
              console.log(`回复用户:`, item.coursereplyCLF[0].user);
              if (item.coursereplyCLF[0].user) {
                console.log(`回复用户昵称:`, item.coursereplyCLF[0].user.nickName);
              }
            }
          });
          
          // 处理数据，为每个问题添加showReplies属性
          const processedData = res.data.data.map(item => {
            // 确保coursereplyCLF是数组
            const coursereplyCLF = Array.isArray(item.coursereplyCLF) ? item.coursereplyCLF : [];
            
            // 确保每个回复的user对象存在
            coursereplyCLF.forEach(reply => {
              if (!reply.user) {
                reply.user = { nickName: '匿名用户' };
              }
            });
            
            return Object.assign({}, item, {
              coursereplyCLF: coursereplyCLF,
              showReplies: false
            });
          });
          
          // 更新数据
          this.setData({
            replyCountPosts: processedData,
            currentTab: 'replyCount'
          });
          
          console.log('处理后的回复数量数据：', processedData);
          
          wx.showToast({
            title: '数据已获取',
            icon: 'success'
          });
        } else {
          this.setData({
            replyCountPosts: []
          });
          wx.showToast({
            title: '暂无数据',
            icon: 'none'
          });
        }
      },
      fail: (err) => {
        console.error('获取回复数量数据失败：', err);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'none'
        });
      },
      complete: () => {
        wx.hideLoading();
      }
    });
  },

  // 修改课堂交流选项卡点击事件
  handleTabClick(e) {
    const tab = e.currentTarget.dataset.tab;
    
    if (tab === 'latest') {
      this.getLatestPosts();
    } else if (tab === 'lastReply') {
      this.getLastReplyPosts();
    } else if (tab === 'replyCount') {
      this.getReplyCountPosts();
    }
  },

  // 添加购买课程方法
  buyCourse() {
    // 获取用户信息
    const userInfo = wx.getStorageSync('user');
    if (!userInfo) {
        wx.showToast({
            title: '请先登录',
            icon: 'none'
        });
        return;
    }

    // 获取当前日期，格式为yyyy-MM-dd
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    const purchasetime = `${year}-${month}-${day}`;

    // 显示确认对话框
    wx.showModal({
        title: '确认购买',
        content: `确定要购买该课程吗？\n价格：¥${this.data.coursePrice}`,
        confirmText: '确认购买',
        cancelText: '再想想',
        success: (res) => {
            // 构造购买课程对象
            const coursepurchase = {
                id: '',  // 空字符串，让数据库自动生成ID
                createtime: purchasetime,
                purchasetime: purchasetime,  // 购买时间
                purchaseprice: this.data.coursePrice,  // 使用当前课程价格
                userId: userInfo.userId || userInfo.id,
                courseId: this.data.courseId,
                status: res.confirm ? 2 : 1  // 2表示已购买，1表示未支付
            };

            console.log('购买课程参数：', coursepurchase);

            // 显示加载提示
            wx.showLoading({
                title: res.confirm ? '购买中...' : '保存中...',
                mask: true
            });

            // 调用购买课程接口
            wx.request({
                url: 'http://localhost:8080/courseDetails/buyCourse',
                method: 'POST',
                header: {
                    'content-type': 'application/x-www-form-urlencoded'
                },
                data: `id=&createtime=${coursepurchase.createtime}&purchasetime=${coursepurchase.purchasetime}&purchaseprice=${coursepurchase.purchaseprice}&userId=${coursepurchase.userId}&courseId=${coursepurchase.courseId}&status=${coursepurchase.status}`,
                success: (res) => {
                    console.log('购买课程接口响应：', res.data);
                    if (res.data.code === 1) {
                        wx.showToast({
                            title: coursepurchase.status === 2 ? '购买成功' : '已加入待付款',
                            icon: 'success'
                        });
                        
                        // 只有在确认购买时才更新学习人数
                        if (coursepurchase.status === 2) {
                            this.setData({
                                xuecount: this.data.xuecount + 1
                            });
                        }
                    } else {
                        wx.showToast({
                            title: res.data.msg || '操作失败',
                            icon: 'none'
                        });
                    }
                },
                fail: (err) => {
                    console.error('购买课程失败：', err);
                    wx.showToast({
                        title: '网络错误，请重试',
                        icon: 'none'
                    });
                },
                complete: () => {
                    wx.hideLoading();
                }
            });
        }
    });
  },

  // 收藏课程
  collectCourse() {
    // 获取用户信息
    const userInfo = wx.getStorageSync('user');
    if (!userInfo) {
        wx.showToast({
            title: '请先登录',
            icon: 'none'
        });
        return;
    }

    wx.showLoading({
        title: '处理中...',
        mask: true
    });

    // 根据当前收藏状态决定使用不同的请求方法和接口
    if (this.data.isCollected) {
        // 取消收藏 - 使用 DELETE 请求
        wx.request({
            url: 'http://localhost:8080/courseDetails/cancelCollectCourse',
            method: 'DELETE',
            header: {
                'content-type': 'application/x-www-form-urlencoded'
            },
            data: `userId=${userInfo.userId || userInfo.id}&courseId=${this.data.courseId}`,
            success: (res) => {
                console.log('取消收藏接口响应：', res.data);
                if (res.data.code === 1) {
                    this.setData({
                        isCollected: false,
                        collects: this.data.collects - 1
                    });
                    wx.showToast({
                        title: '取消收藏',
                        icon: 'success'
                    });
                } else {
                    wx.showToast({
                        title: res.data.msg || '取消失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('取消收藏失败：', err);
                wx.showToast({
                    title: '网络错误，请重试',
                    icon: 'none'
                });
            },
            complete: () => {
                wx.hideLoading();
            }
        });
    } else {
        // 添加收藏 - 使用 POST 请求
        wx.request({
            url: 'http://localhost:8080/courseDetails/collectCourse',
            method: 'POST',
            header: {
                'content-type': 'application/x-www-form-urlencoded'
            },
            data: `id=&userId=${userInfo.userId || userInfo.id}&courseId=${this.data.courseId}`,
            success: (res) => {
                console.log('收藏课程接口响应：', res.data);
                if (res.data.code === 1) {
                    this.setData({
                        isCollected: true,
                        collects: this.data.collects + 1
                    });
                    wx.showToast({
                        title: '收藏成功',
                        icon: 'success'
                    });
                } else {
                    wx.showToast({
                        title: res.data.msg || '收藏失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error('收藏失败：', err);
                wx.showToast({
                    title: '网络错误，请重试',
                    icon: 'none'
                });
            },
            complete: () => {
                wx.hideLoading();
            }
        });
    }
  }
})